// 题目要求：
// 给定一个长度为 n 的字符串，要求找最长非递减子序列，找到后返回剩余的长度
// 1 <= n <= 1000000

// 解题思路：
// 首先不能用动态规划，因为动态规划的时间复杂度是 n * n，这是会超时的
// 所以应该考虑 n * logn 的算法，因为必须要遍历这个数组，时间复杂度一定会有 n
// 进一步考虑，时间复杂度为 logn 的算法，只有堆和二分，这里不涉及堆，因此会考虑用二分算法
// 找最长递增子序列，以 i 位置为例：
// 此时要考虑的问题是，s[i] 能跟到谁的后面
// 前面考虑用一个数组 ch 和一个 pos 来维护前面子序列的信息
// pos 表示当前能达到的最长的子序列的长度，ch 里面存的是子序列长度达到 j 时候的最后一个字符
// 如果 s[i] 比 ch[pos] 还大，就可以跟到 ch[pos] 后面，就将 s[i] 放到 ch[++pos] 的位置
// 贪心：如果 s[i] 能跟到 ch[j] 后面，就要跟 j + 1 位置的元素比较，如果比 ch[j + 1] 小，s[i] 就可以替换 cg[j + 1]
// 因为后面如果还有字符可以跟到 ch[j + 1] 后面，就一定能够跟到 s[i] 后面
// 如何快速找到 ch[j + 1]，可以使用二分的方式，因为 ch 数组中，下标和 ch 里面存的字符是非递减的，有单调性

import java.util.*;



public class TheLongestNonDecreasingSubsequence {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();
        char[] s = in.next().toCharArray();

        char[] ch = new char[n + 1];
        int pos = 0;

        for(int i = 0; i < n; i++){
            if(pos == 0 || s[i] >= ch[pos]){
                pos++;
                ch[pos] = s[i];
            }else{
                int left = 0;
                int right = pos;
                while(left < right){
                    int mid = (right - left) / 2 + left;
                    if(ch[mid] <= s[i]){
                        left = mid + 1;
                    }else{
                        right = mid;
                    }
                }
                if(s[i] < ch[left]){
                    ch[left] = s[i];
                }
            }
        }

        System.out.println(n - pos);
    }
}
